home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / lang / Python16_Src.lha / Python16_Source / Modules / flmodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-03  |  50.6 KB  |  2,502 lines
  1. /* FL module -- interface to Mark Overmars' FORMS Library. */
  2.  
  3. /* This code works with FORMS version 2.2 (if you defined
  4.    OBSOLETE_FORMS_CALLS), and 2.3.
  5.    FORMS can be ftp'ed from ftp.cs.ruu.nl (131.211.80.17), directory
  6.    /pub/SGI/FORMS. */
  7.  
  8. /* A half-hearted attempt has been made to allow programs using this
  9.  * module to exploit parallelism (through the threads module). No provisions
  10.  * have been made for multiple threads to use this module at the same time,
  11.  * though. So, a program with a forms thread and a non-forms thread will work
  12.  * fine but a program with two threads using forms will probably crash (unless
  13.  * the program takes precaution to ensure that only one thread can be in
  14.  * this module at any time). This will have to be fixed some time.
  15.  * (A fix will probably also have to synchronise with the gl module).
  16.  */
  17.  
  18. #include "Python.h"
  19. #include "forms.h"
  20. #include "structmember.h"
  21.  
  22. /* Generic Forms Objects */
  23.  
  24. typedef struct {
  25.     PyObject_HEAD
  26.     FL_OBJECT *ob_generic;
  27.     PyMethodDef *ob_methods;
  28.     PyObject *ob_callback;
  29.     PyObject *ob_callback_arg;
  30. } genericobject;
  31.  
  32. staticforward PyTypeObject GenericObjecttype;
  33.  
  34. #define is_genericobject(g) ((g)->ob_type == &GenericObjecttype)
  35.  
  36. /* List of all objects (XXX this should be a hash table on address...) */
  37.  
  38. static PyObject *allgenerics = NULL;
  39. static int nfreeslots = 0;
  40.  
  41. /* Add an object to the list of known objects */
  42.  
  43. static void
  44. knowgeneric(g)
  45.     genericobject *g;
  46. {
  47.     int i, n;
  48.     /* Create the list if it doesn't already exist */
  49.     if (allgenerics == NULL) {
  50.         allgenerics = PyList_New(0);
  51.         if (allgenerics == NULL) {
  52.             PyErr_Clear();
  53.             return; /* Too bad, live without allgenerics... */
  54.         }
  55.     }
  56.     if (nfreeslots > 0) {
  57.         /* Search the list for reusable slots (NULL items) */
  58.         /* XXX This can be made faster! */
  59.         n = PyList_Size(allgenerics);
  60.         for (i = 0; i < n; i++) {
  61.             if (PyList_GetItem(allgenerics, i) == NULL) {
  62.                 Py_INCREF(g);
  63.                 PyList_SetItem(allgenerics, i, (PyObject *)g);
  64.                 nfreeslots--;
  65.                 return;
  66.             }
  67.         }
  68.         /* Strange... no free slots found... */
  69.         nfreeslots = 0;
  70.     }
  71.     /* No free entries, append new item to the end */
  72.     PyList_Append(allgenerics, (PyObject *)g);
  73. }
  74.  
  75. /* Find an object in the list of known objects */
  76.  
  77. static genericobject *
  78. findgeneric(generic)
  79.     FL_OBJECT *generic;
  80. {
  81.     int i, n;
  82.     genericobject *g;
  83.     
  84.     if (allgenerics == NULL)
  85.         return NULL; /* No objects known yet */
  86.     n = PyList_Size(allgenerics);
  87.     for (i = 0; i < n; i++) {
  88.         g = (genericobject *)PyList_GetItem(allgenerics, i);
  89.         if (g != NULL && g->ob_generic == generic)
  90.             return g;
  91.     }
  92.     return NULL; /* Unknown object */
  93. }
  94.  
  95. /* Remove an object from the list of known objects */
  96.  
  97. static void
  98. forgetgeneric(g)
  99.     genericobject *g;
  100. {
  101.     int i, n;
  102.     
  103.     Py_XDECREF(g->ob_callback);
  104.     g->ob_callback = NULL;
  105.     Py_XDECREF(g->ob_callback_arg);
  106.     g->ob_callback_arg = NULL;
  107.     if (allgenerics == NULL)
  108.         return; /* No objects known yet */
  109.     n = PyList_Size(allgenerics);
  110.     for (i = 0; i < n; i++) {
  111.         if (g == (genericobject *)PyList_GetItem(allgenerics, i)) {
  112.             PyList_SetItem(allgenerics, i, (PyObject *)NULL);
  113.             nfreeslots++;
  114.             break;
  115.         }
  116.     }
  117. }
  118.  
  119. /* Called when a form is about to be freed --
  120.    remove all the objects that we know about from it. */
  121.  
  122. static void
  123. releaseobjects(form)
  124.     FL_FORM *form;
  125. {
  126.     int i, n;
  127.     genericobject *g;
  128.     
  129.     if (allgenerics == NULL)
  130.         return; /* No objects known yet */
  131.     n = PyList_Size(allgenerics);
  132.     for (i = 0; i < n; i++) {
  133.         g = (genericobject *)PyList_GetItem(allgenerics, i);
  134.         if (g != NULL && g->ob_generic->form == form) {
  135.             fl_delete_object(g->ob_generic);
  136.             /* The object is now unreachable for
  137.                do_forms and check_forms, so
  138.                delete it from the list of known objects */
  139.             Py_XDECREF(g->ob_callback);
  140.             g->ob_callback = NULL;
  141.             Py_XDECREF(g->ob_callback_arg);
  142.             g->ob_callback_arg = NULL;
  143.             PyList_SetItem(allgenerics, i, (PyObject *)NULL);
  144.             nfreeslots++;
  145.         }
  146.     }
  147. }
  148.  
  149.  
  150. /* Methods of generic objects */
  151.  
  152. static PyObject *
  153. generic_set_call_back(g, args)
  154.     genericobject *g;
  155.     PyObject *args;
  156. {
  157.     if (args == NULL) {
  158.         Py_XDECREF(g->ob_callback);
  159.         Py_XDECREF(g->ob_callback_arg);
  160.         g->ob_callback = NULL;
  161.         g->ob_callback_arg = NULL;
  162.     }
  163.     else {
  164.         if (!PyTuple_Check(args) || PyTuple_Size(args) != 2) {
  165.             PyErr_BadArgument();
  166.             return NULL;
  167.         }
  168.         Py_XDECREF(g->ob_callback);
  169.         Py_XDECREF(g->ob_callback_arg);
  170.         g->ob_callback = PyTuple_GetItem(args, 0);
  171.         Py_INCREF(g->ob_callback);
  172.         g->ob_callback_arg = PyTuple_GetItem(args, 1);
  173.         Py_INCREF(g->ob_callback_arg);
  174.     }
  175.     Py_INCREF(Py_None);
  176.     return Py_None;
  177. }
  178.  
  179. static PyObject *
  180. generic_call(g, args, func)
  181.     genericobject *g;
  182.     PyObject *args;
  183.     void (*func)(FL_OBJECT *);
  184. {
  185.     if (!PyArg_NoArgs(args))
  186.         return NULL;
  187.     (*func)(g->ob_generic);
  188.     Py_INCREF(Py_None);
  189.     return Py_None;
  190. }
  191.  
  192. static PyObject *
  193. generic_delete_object(g, args)
  194.     genericobject *g;
  195.     PyObject *args;
  196. {
  197.     PyObject *res;
  198.     res = generic_call(g, args, fl_delete_object);
  199.     if (res != NULL)
  200.         forgetgeneric(g);
  201.     return res;
  202. }
  203.  
  204. static PyObject *
  205. generic_show_object(g, args)
  206.     genericobject *g;
  207.     PyObject *args;
  208. {
  209.     return generic_call(g, args, fl_show_object);
  210. }
  211.  
  212. static PyObject *
  213. generic_hide_object(g, args)
  214.     genericobject *g;
  215.     PyObject *args;
  216. {
  217.     return generic_call(g, args, fl_hide_object);
  218. }
  219.  
  220. static PyObject *
  221. generic_redraw_object(g, args)
  222.     genericobject *g;
  223.     PyObject *args;
  224. {
  225.     return generic_call(g, args, fl_redraw_object);
  226. }
  227.  
  228. #ifdef OBSOLETE_FORMS_CALLS
  229.  
  230.  /* (un)freeze_object() are obsolete in FORMS 2.2 and unsupported
  231.     in 2.3.  Since there's no foolproof way to tell which version we're
  232.     using, we omit them unconditionally. */
  233.  
  234. static PyObject *
  235. generic_freeze_object(g, args)
  236.     genericobject *g;
  237.     PyObject *args;
  238. {
  239.     return generic_call(g, args, fl_freeze_object);
  240. }
  241.  
  242. static PyObject *
  243. generic_unfreeze_object(g, args)
  244.     genericobject *g;
  245.     PyObject *args;
  246. {
  247.     return generic_call(g, args, fl_unfreeze_object);
  248. }
  249.  
  250. #endif /* OBSOLETE_FORMS_CALLS */
  251.  
  252. static PyObject *
  253. generic_activate_object(g, args)
  254.     genericobject *g;
  255.     PyObject *args;
  256. {
  257.     return generic_call(g, args, fl_activate_object);
  258. }
  259.  
  260. static PyObject *
  261. generic_deactivate_object(g, args)
  262.     genericobject *g;
  263.     PyObject *args;
  264. {
  265.     return generic_call(g, args, fl_deactivate_object);
  266. }
  267.  
  268. static PyObject *
  269. generic_set_object_shortcut(g, args)
  270.     genericobject *g;
  271.     PyObject *args;
  272. {
  273.     char *str;
  274.     if (!PyArg_Parse(args, "s", &str))
  275.         return NULL;
  276.     fl_set_object_shortcut(g->ob_generic, str);
  277.     Py_INCREF(Py_None);
  278.     return Py_None;
  279. }
  280.  
  281. static PyMethodDef generic_methods[] = {
  282.     {"set_call_back",    (PyCFunction)generic_set_call_back},
  283.     {"delete_object",    (PyCFunction)generic_delete_object},
  284.     {"show_object",        (PyCFunction)generic_show_object},
  285.     {"hide_object",        (PyCFunction)generic_hide_object},
  286.     {"redraw_object",    (PyCFunction)generic_redraw_object},
  287. #ifdef OBSOLETE_FORMS_CALLS
  288.     {"freeze_object",    (PyCFunction)generic_freeze_object},
  289.     {"unfreeze_object",    (PyCFunction)generic_unfreeze_object},
  290. #endif
  291.     {"activate_object",    (PyCFunction)generic_activate_object},
  292.     {"deactivate_object",    (PyCFunction)generic_deactivate_object},
  293.     {"set_object_shortcut",    (PyCFunction)generic_set_object_shortcut},
  294.     {NULL,            NULL}        /* sentinel */
  295. };
  296.  
  297. static void
  298. generic_dealloc(g)
  299.     genericobject *g;
  300. {
  301.     fl_free_object(g->ob_generic);
  302.     Py_XDECREF(g->ob_callback);
  303.     Py_XDECREF(g->ob_callback_arg);
  304.     PyObject_Del(g);
  305. }
  306.  
  307. #define OFF(x) offsetof(FL_OBJECT, x)
  308.  
  309. static struct memberlist generic_memberlist[] = {
  310.     {"objclass",    T_INT,        OFF(objclass),    RO},
  311.     {"type",    T_INT,        OFF(type),    RO},
  312.     {"boxtype",    T_INT,        OFF(boxtype)},
  313.     {"x",        T_FLOAT,    OFF(x)},
  314.     {"y",        T_FLOAT,    OFF(y)},
  315.     {"w",        T_FLOAT,    OFF(w)},
  316.     {"h",        T_FLOAT,    OFF(h)},
  317.     {"col1",    T_INT,        OFF(col1)},
  318.     {"col2",    T_INT,        OFF(col2)},
  319.     {"align",    T_INT,        OFF(align)},
  320.     {"lcol",    T_INT,        OFF(lcol)},
  321.     {"lsize",    T_FLOAT,    OFF(lsize)},
  322.     /* "label" is treated specially! */
  323.     {"lstyle",    T_INT,        OFF(lstyle)},
  324.     {"pushed",    T_INT,        OFF(pushed),    RO},
  325.     {"focus",    T_INT,        OFF(focus),    RO},
  326.     {"belowmouse",    T_INT,        OFF(belowmouse),RO},
  327. /*    {"frozen",    T_INT,        OFF(frozen),    RO},    */
  328.     {"active",    T_INT,        OFF(active)},
  329.     {"input",    T_INT,        OFF(input)},
  330.     {"visible",    T_INT,        OFF(visible),    RO},
  331.     {"radio",    T_INT,        OFF(radio)},
  332.     {"automatic",    T_INT,        OFF(automatic)},
  333.     {NULL}    /* Sentinel */
  334. };
  335.  
  336. #undef OFF
  337.  
  338. static PyObject *
  339. generic_getattr(g, name)
  340.     genericobject *g;
  341.     char *name;
  342. {
  343.     PyObject *meth;
  344.  
  345.     /* XXX Ought to special-case name "__methods__" */
  346.     if (g-> ob_methods) {
  347.         meth = Py_FindMethod(g->ob_methods, (PyObject *)g, name);
  348.         if (meth != NULL) return meth;
  349.         PyErr_Clear();
  350.     }
  351.  
  352.     meth = Py_FindMethod(generic_methods, (PyObject *)g, name);
  353.     if (meth != NULL)
  354.         return meth;
  355.     PyErr_Clear();
  356.  
  357.     /* "label" is an exception, getmember only works for char pointers,
  358.        not for char arrays */
  359.     if (strcmp(name, "label") == 0)
  360.         return PyString_FromString(g->ob_generic->label);
  361.  
  362.     return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);
  363. }
  364.  
  365. static int
  366. generic_setattr(g, name, v)
  367.     genericobject *g;
  368.     char *name;
  369.     PyObject *v;
  370. {
  371.     int ret;
  372.  
  373.     if (v == NULL) {
  374.         PyErr_SetString(PyExc_TypeError,
  375.                 "can't delete forms object attributes");
  376.         return -1;
  377.     }
  378.  
  379.     /* "label" is an exception: setmember doesn't set strings;
  380.        and FORMS wants you to call a function to set the label */
  381.     if (strcmp(name, "label") == 0) {
  382.         if (!PyString_Check(v)) {
  383.             PyErr_SetString(PyExc_TypeError,
  384.                     "label attr must be string");
  385.             return -1;
  386.         }
  387.         fl_set_object_label(g->ob_generic, PyString_AsString(v));
  388.         return 0;
  389.     }
  390.  
  391.     ret = PyMember_Set((char *)g->ob_generic, generic_memberlist, name, v);
  392.  
  393.     /* Rather than calling all the various set_object_* functions,
  394.        we call fl_redraw_object here.  This is sometimes redundant
  395.        but I doubt that's a big problem */
  396.     if (ret == 0)
  397.         fl_redraw_object(g->ob_generic);
  398.  
  399.     return ret;
  400. }
  401.  
  402. static PyObject *
  403. generic_repr(g)
  404.     genericobject *g;
  405. {
  406.     char buf[100];
  407.     sprintf(buf, "<FORMS_object at %lx, objclass=%d>",
  408.         (long)g, g->ob_generic->objclass);
  409.     return PyString_FromString(buf);
  410. }
  411.  
  412. static PyTypeObject GenericObjecttype = {
  413.     PyObject_HEAD_INIT(&PyType_Type)
  414.     0,                /*ob_size*/
  415.     "FORMS_object",            /*tp_name*/
  416.     sizeof(genericobject),        /*tp_size*/
  417.     0,                /*tp_itemsize*/
  418.     /* methods */
  419.     (destructor)generic_dealloc,    /*tp_dealloc*/
  420.     0,                /*tp_print*/
  421.     (getattrfunc)generic_getattr,    /*tp_getattr*/
  422.     (setattrfunc)generic_setattr,    /*tp_setattr*/
  423.     0,                /*tp_compare*/
  424.     (reprfunc)generic_repr,        /*tp_repr*/
  425. };
  426.  
  427. static PyObject *
  428. newgenericobject(generic, methods)
  429.     FL_OBJECT *generic;
  430.     PyMethodDef *methods;
  431. {
  432.     genericobject *g;
  433.     g = PyObject_New(genericobject, &GenericObjecttype);
  434.     if (g == NULL)
  435.         return NULL;
  436.     g-> ob_generic = generic;
  437.     g->ob_methods = methods;
  438.     g->ob_callback = NULL;
  439.     g->ob_callback_arg = NULL;
  440.     knowgeneric(g);
  441.     return (PyObject *)g;
  442. }
  443.  
  444. /**********************************************************************/
  445. /* Some common calling sequences */
  446.  
  447. /* void func (object, float) */
  448. static PyObject *
  449. call_forms_INf (func, obj, args)
  450.     void (*func)(FL_OBJECT *, float);
  451.     FL_OBJECT *obj;
  452.     PyObject *args;
  453. {
  454.     float parameter;
  455.  
  456.     if (!PyArg_Parse(args, "f", ¶meter)) return NULL;
  457.  
  458.     (*func) (obj, parameter);
  459.  
  460.     Py_INCREF(Py_None);
  461.     return Py_None;
  462. }
  463.  
  464. /* void func (object, float) */
  465. static PyObject *
  466. call_forms_INfINf (func, obj, args)
  467.     void (*func)(FL_OBJECT *, float, float);
  468.     FL_OBJECT *obj;
  469.     PyObject *args;
  470. {
  471.     float par1, par2;
  472.  
  473.     if (!PyArg_Parse(args, "(ff)", &par1, &par2)) return NULL;
  474.  
  475.     (*func) (obj, par1, par2);
  476.  
  477.     Py_INCREF(Py_None);
  478.     return Py_None;
  479. }
  480.  
  481. /* void func (object, int) */
  482. static PyObject *
  483. call_forms_INi (func, obj, args)
  484.     void (*func)(FL_OBJECT *, int);
  485.     FL_OBJECT *obj;
  486.     PyObject *args;
  487. {
  488.     int parameter;
  489.  
  490.     if (!PyArg_Parse(args, "i", ¶meter)) return NULL;
  491.  
  492.     (*func) (obj, parameter);
  493.  
  494.     Py_INCREF(Py_None);
  495.     return Py_None;
  496. }
  497.  
  498. /* void func (object, char) */
  499. static PyObject *
  500. call_forms_INc (func, obj, args)
  501.     void (*func)(FL_OBJECT *, int);
  502.     FL_OBJECT *obj;
  503.     PyObject *args;
  504. {
  505.     char *a;
  506.  
  507.     if (!PyArg_Parse(args, "s", &a)) return NULL;
  508.  
  509.     (*func) (obj, a[0]);
  510.  
  511.     Py_INCREF(Py_None);
  512.     return Py_None;
  513. }
  514.  
  515. /* void func (object, string) */
  516. static PyObject *
  517. call_forms_INstr (func, obj, args)
  518.     void (*func)(FL_OBJECT *, char *);
  519.     FL_OBJECT *obj;
  520.     PyObject *args;
  521. {
  522.     char *a;
  523.  
  524.     if (!PyArg_Parse(args, "s", &a)) return NULL;
  525.  
  526.     (*func) (obj, a);
  527.  
  528.     Py_INCREF(Py_None);
  529.     return Py_None;
  530. }
  531.  
  532.  
  533. /* void func (object, int, string) */
  534. static PyObject *
  535. call_forms_INiINstr (func, obj, args)
  536.     void (*func)(FL_OBJECT *, int, char *);
  537.     FL_OBJECT *obj;
  538.     PyObject *args;
  539. {
  540.     char *b;
  541.     int a;
  542.     
  543.     if (!PyArg_Parse(args, "(is)", &a, &b)) return NULL;
  544.     
  545.     (*func) (obj, a, b);
  546.     
  547.     Py_INCREF(Py_None);
  548.     return Py_None;
  549. }
  550.  
  551. #ifdef UNUSED
  552. /* void func (object, int, int) */
  553. static PyObject *
  554. call_forms_INiINi (func, obj, args)
  555.     void (*func)(FL_OBJECT *, int, int);
  556.     FL_OBJECT *obj;
  557.     PyObject *args;
  558. {
  559.     int par1, par2;
  560.     
  561.     if (!PyArg_Parse(args, "(ii)", &par1, &par2)) return NULL;
  562.     
  563.     (*func) (obj, par1, par2);
  564.     
  565.     Py_INCREF(Py_None);
  566.     return Py_None;
  567. }
  568. #endif
  569.  
  570. /* int func (object) */
  571. static PyObject *
  572. call_forms_Ri (func, obj, args)
  573.     int (*func)(FL_OBJECT *);
  574.     FL_OBJECT *obj;
  575.     PyObject *args;
  576. {
  577.     int retval;
  578.     
  579.     if (!PyArg_NoArgs(args)) return NULL;
  580.     
  581.     retval = (*func) (obj);
  582.     
  583.     return PyInt_FromLong ((long) retval);
  584. }
  585.  
  586. /* char * func (object) */
  587. static PyObject *
  588. call_forms_Rstr (func, obj, args)
  589.     char * (*func)(FL_OBJECT *);
  590.     FL_OBJECT *obj;
  591.     PyObject *args;
  592. {
  593.     char *str;
  594.     
  595.     if (!PyArg_NoArgs(args)) return NULL;
  596.     
  597.     str = (*func) (obj);
  598.     
  599.     if (str == NULL) {
  600.         Py_INCREF(Py_None);
  601.         return Py_None;
  602.     }
  603.     return PyString_FromString (str);
  604. }
  605.  
  606. /* int func (object) */
  607. static PyObject *
  608. call_forms_Rf (func, obj, args)
  609.     float (*func)(FL_OBJECT *);
  610.     FL_OBJECT *obj;
  611.     PyObject *args;
  612. {
  613.     float retval;
  614.     
  615.     if (!PyArg_NoArgs(args)) return NULL;
  616.     
  617.     retval = (*func) (obj);
  618.     
  619.     return PyFloat_FromDouble (retval);
  620. }
  621.  
  622. static PyObject *
  623. call_forms_OUTfOUTf (func, obj, args)
  624.     void (*func)(FL_OBJECT *, float *, float *);
  625.     FL_OBJECT *obj;
  626.     PyObject *args;
  627. {
  628.     float f1, f2;
  629.     
  630.     if (!PyArg_NoArgs(args)) return NULL;
  631.     
  632.     (*func) (obj, &f1, &f2);
  633.  
  634.     return Py_BuildValue("(ff)", f1, f2);
  635. }
  636.  
  637. #ifdef UNUSED
  638. static PyObject *
  639. call_forms_OUTf (func, obj, args)
  640.     void (*func)(FL_OBJECT *, float *);
  641.     FL_OBJECT *obj;
  642.     PyObject *args;
  643. {
  644.     float f;
  645.  
  646.     if (!PyArg_NoArgs(args)) return NULL;
  647.  
  648.     (*func) (obj, &f);
  649.  
  650.     return PyFloat_FromDouble (f);
  651. }
  652. #endif
  653.  
  654. /**********************************************************************/
  655. /* Class : browser */
  656.  
  657. static PyObject *
  658. set_browser_topline(g, args)
  659.     genericobject *g;
  660.     PyObject *args;
  661. {
  662.     return call_forms_INi (fl_set_browser_topline, g-> ob_generic, args);
  663. }
  664.  
  665. static PyObject *
  666. clear_browser(g, args)
  667.     genericobject *g;
  668.     PyObject *args;
  669. {
  670.     return generic_call (g, args, fl_clear_browser);
  671. }
  672.  
  673. static PyObject *
  674. add_browser_line (g, args)
  675.     genericobject *g;
  676.     PyObject *args;
  677. {
  678.     return call_forms_INstr (fl_add_browser_line, g-> ob_generic, args);
  679. }
  680.  
  681. static PyObject *
  682. addto_browser (g, args)
  683.     genericobject *g;
  684.     PyObject *args;
  685. {
  686.     return call_forms_INstr (fl_addto_browser, g-> ob_generic, args);
  687. }
  688.  
  689. static PyObject *
  690. insert_browser_line (g, args)
  691.     genericobject *g;
  692.     PyObject *args;
  693. {
  694.     return call_forms_INiINstr (fl_insert_browser_line,
  695.                     g-> ob_generic, args);
  696. }
  697.  
  698. static PyObject *
  699. delete_browser_line (g, args)
  700.     genericobject *g;
  701.     PyObject *args;
  702. {
  703.     return call_forms_INi (fl_delete_browser_line, g-> ob_generic, args);
  704. }
  705.  
  706. static PyObject *
  707. replace_browser_line (g, args)
  708.     genericobject *g;
  709.     PyObject *args;
  710. {
  711.     return call_forms_INiINstr (fl_replace_browser_line,
  712.                     g-> ob_generic, args);
  713. }
  714.  
  715. static PyObject *
  716. get_browser_line(g, args)
  717.     genericobject *g;
  718.     PyObject *args;
  719. {
  720.     int i;
  721.     char *str;
  722.  
  723.     if (!PyArg_Parse(args, "i", &i))
  724.         return NULL;
  725.  
  726.     str = fl_get_browser_line (g->ob_generic, i);
  727.  
  728.     if (str == NULL) {
  729.         Py_INCREF(Py_None);
  730.         return Py_None;
  731.     }
  732.     return PyString_FromString (str);
  733. }
  734.  
  735. static PyObject *
  736. load_browser (g, args)
  737.     genericobject *g;
  738.     PyObject *args;
  739. {
  740.     /* XXX strictly speaking this is wrong since fl_load_browser
  741.        XXX returns int, not void */
  742.     return call_forms_INstr (fl_load_browser, g-> ob_generic, args);
  743. }
  744.  
  745. static PyObject *
  746. get_browser_maxline(g, args)
  747.     genericobject *g;
  748.     PyObject *args;
  749. {
  750.     return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic, args);
  751. }
  752.  
  753. static PyObject *
  754. select_browser_line (g, args)
  755.     genericobject *g;
  756.     PyObject *args;
  757. {
  758.     return call_forms_INi (fl_select_browser_line, g-> ob_generic, args);
  759. }
  760.  
  761. static PyObject *
  762. deselect_browser_line (g, args)
  763.     genericobject *g;
  764.     PyObject *args;
  765. {
  766.     return call_forms_INi (fl_deselect_browser_line, g-> ob_generic, args);
  767. }
  768.  
  769. static PyObject *
  770. deselect_browser (g, args)
  771.     genericobject *g;
  772.     PyObject *args;
  773. {
  774.     return generic_call (g, args, fl_deselect_browser);
  775. }
  776.  
  777. static PyObject *
  778. isselected_browser_line (g, args)
  779.     genericobject *g;
  780.     PyObject *args;
  781. {
  782.     int i, j;
  783.     
  784.     if (!PyArg_Parse(args, "i", &i))
  785.         return NULL;
  786.     
  787.     j = fl_isselected_browser_line (g->ob_generic, i);
  788.     
  789.     return PyInt_FromLong (j);
  790. }
  791.  
  792. static PyObject *
  793. get_browser (g, args)
  794.     genericobject *g;
  795.     PyObject *args;
  796. {
  797.     return call_forms_Ri (fl_get_browser, g-> ob_generic, args);
  798. }
  799.  
  800. static PyObject *
  801. set_browser_fontsize (g, args)
  802.     genericobject *g;
  803.     PyObject *args;
  804. {
  805.     return call_forms_INf (fl_set_browser_fontsize, g-> ob_generic, args);
  806. }
  807.  
  808. static PyObject *
  809. set_browser_fontstyle (g, args)
  810.     genericobject *g;
  811.     PyObject *args;
  812. {
  813.     return call_forms_INi (fl_set_browser_fontstyle, g-> ob_generic, args);
  814. }
  815.  
  816. static PyObject *
  817. set_browser_specialkey (g, args)
  818.     genericobject *g;
  819.     PyObject *args;
  820. {
  821.     return call_forms_INc(fl_set_browser_specialkey, g-> ob_generic, args);
  822. }
  823.  
  824. static PyMethodDef browser_methods[] = {
  825.     {"set_browser_topline",        (PyCFunction)set_browser_topline},
  826.     {"clear_browser",        (PyCFunction)clear_browser},
  827.     {"add_browser_line",        (PyCFunction)add_browser_line},
  828.     {"addto_browser",        (PyCFunction)addto_browser},
  829.     {"insert_browser_line",        (PyCFunction)insert_browser_line},
  830.     {"delete_browser_line",        (PyCFunction)delete_browser_line},
  831.     {"replace_browser_line",    (PyCFunction)replace_browser_line},
  832.     {"get_browser_line",        (PyCFunction)get_browser_line},
  833.     {"load_browser",        (PyCFunction)load_browser},
  834.     {"get_browser_maxline",        (PyCFunction)get_browser_maxline},
  835.     {"select_browser_line",        (PyCFunction)select_browser_line},
  836.     {"deselect_browser_line",    (PyCFunction)deselect_browser_line},
  837.     {"deselect_browser",        (PyCFunction)deselect_browser},
  838.     {"isselected_browser_line",    (PyCFunction)isselected_browser_line},
  839.     {"get_browser",            (PyCFunction)get_browser},
  840.     {"set_browser_fontsize",    (PyCFunction)set_browser_fontsize},
  841.     {"set_browser_fontstyle",    (PyCFunction)set_browser_fontstyle},
  842.     {"set_browser_specialkey",    (PyCFunction)set_browser_specialkey},
  843.     {NULL,                NULL}        /* sentinel */
  844. };
  845.  
  846. /* Class: button */
  847.  
  848. static PyObject *
  849. set_button(g, args)
  850.     genericobject *g;
  851.     PyObject *args;
  852. {
  853.     return call_forms_INi (fl_set_button, g-> ob_generic, args);
  854. }
  855.  
  856. static PyObject *
  857. get_button(g, args)
  858.     genericobject *g;
  859.     PyObject *args;
  860. {
  861.     return call_forms_Ri (fl_get_button, g-> ob_generic, args);
  862. }
  863.  
  864. static PyObject *
  865. get_button_numb(g, args)
  866.     genericobject *g;
  867.     PyObject *args;
  868. {
  869.     return call_forms_Ri (fl_get_button_numb, g-> ob_generic, args);
  870. }
  871.  
  872. static PyObject *
  873. set_button_shortcut(g, args)
  874.     genericobject *g;
  875.     PyObject *args;
  876. {
  877.     return call_forms_INstr (fl_set_button_shortcut, g-> ob_generic, args);
  878. }
  879.  
  880. static PyMethodDef button_methods[] = {
  881.     {"set_button",        (PyCFunction)set_button},
  882.     {"get_button",        (PyCFunction)get_button},
  883.     {"get_button_numb",    (PyCFunction)get_button_numb},
  884.     {"set_button_shortcut",    (PyCFunction)set_button_shortcut},
  885.     {NULL,            NULL}        /* sentinel */
  886. };
  887.  
  888. /* Class: choice */
  889.  
  890. static PyObject *
  891. set_choice(g, args)
  892.     genericobject *g;
  893.     PyObject *args;
  894. {
  895.     return call_forms_INi (fl_set_choice, g-> ob_generic, args);
  896. }
  897.  
  898. static PyObject *
  899. get_choice(g, args)
  900.     genericobject *g;
  901.     PyObject *args;
  902. {
  903.     return call_forms_Ri (fl_get_choice, g-> ob_generic, args);
  904. }
  905.  
  906. static PyObject *
  907. clear_choice (g, args)
  908.     genericobject *g;
  909.     PyObject *args;
  910. {
  911.     return generic_call (g, args, fl_clear_choice);
  912. }
  913.  
  914. static PyObject *
  915. addto_choice (g, args)
  916.     genericobject *g;
  917.     PyObject *args;
  918. {
  919.     return call_forms_INstr (fl_addto_choice, g-> ob_generic, args);
  920. }
  921.  
  922. static PyObject *
  923. replace_choice (g, args)
  924.     genericobject *g;
  925.     PyObject *args;
  926. {
  927.     return call_forms_INiINstr (fl_replace_choice, g-> ob_generic, args);
  928. }
  929.  
  930. static PyObject *
  931. delete_choice (g, args)
  932.     genericobject *g;
  933.     PyObject *args;
  934. {
  935.     return call_forms_INi (fl_delete_choice, g-> ob_generic, args);
  936. }
  937.  
  938. static PyObject *
  939. get_choice_text (g, args)
  940.     genericobject *g;
  941.     PyObject *args;
  942. {
  943.     return call_forms_Rstr (fl_get_choice_text, g-> ob_generic, args);
  944. }
  945.  
  946. static PyObject *
  947. set_choice_fontsize (g, args)
  948.     genericobject *g;
  949.     PyObject *args;
  950. {
  951.     return call_forms_INf (fl_set_choice_fontsize, g-> ob_generic, args);
  952. }
  953.  
  954. static PyObject *
  955. set_choice_fontstyle (g, args)
  956.     genericobject *g;
  957.     PyObject *args;
  958. {
  959.     return call_forms_INi (fl_set_choice_fontstyle, g-> ob_generic, args);
  960. }
  961.  
  962. static PyMethodDef choice_methods[] = {
  963.     {"set_choice",        (PyCFunction)set_choice},
  964.     {"get_choice",        (PyCFunction)get_choice},
  965.     {"clear_choice",    (PyCFunction)clear_choice},
  966.     {"addto_choice",    (PyCFunction)addto_choice},
  967.     {"replace_choice",    (PyCFunction)replace_choice},
  968.     {"delete_choice",    (PyCFunction)delete_choice},
  969.     {"get_choice_text",    (PyCFunction)get_choice_text},
  970.     {"set_choice_fontsize", (PyCFunction)set_choice_fontsize},
  971.     {"set_choice_fontstyle",(PyCFunction)set_choice_fontstyle},
  972.     {NULL,            NULL}        /* sentinel */
  973. };
  974.  
  975. /* Class : Clock */
  976.  
  977. static PyObject *
  978. get_clock(g, args)
  979.     genericobject *g;
  980.     PyObject *args;
  981. {
  982.     int i0, i1, i2;
  983.  
  984.     if (!PyArg_NoArgs(args))
  985.         return NULL;
  986.  
  987.     fl_get_clock (g->ob_generic, &i0, &i1, &i2);
  988.  
  989.     return Py_BuildValue("(iii)", i0, i1, i2);
  990. }
  991.  
  992. static PyMethodDef clock_methods[] = {
  993.     {"get_clock",        (PyCFunction)get_clock},
  994.     {NULL,            NULL}        /* sentinel */
  995. };
  996.  
  997. /* CLass : Counters */
  998.  
  999. static PyObject *
  1000. get_counter_value(g, args)
  1001.     genericobject *g;
  1002.     PyObject *args;
  1003. {
  1004.     return call_forms_Rf (fl_get_counter_value, g-> ob_generic, args);
  1005. }
  1006.  
  1007. static PyObject *
  1008. set_counter_value (g, args)
  1009.     genericobject *g;
  1010.     PyObject *args;
  1011. {
  1012.     return call_forms_INf (fl_set_counter_value, g-> ob_generic, args);
  1013. }
  1014.  
  1015. static PyObject *
  1016. set_counter_precision (g, args)
  1017.     genericobject *g;
  1018.     PyObject *args;
  1019. {
  1020.     return call_forms_INi (fl_set_counter_precision, g-> ob_generic, args);
  1021. }
  1022.  
  1023. static PyObject *
  1024. set_counter_bounds (g, args)
  1025.     genericobject *g;
  1026.     PyObject *args;
  1027. {
  1028.     return call_forms_INfINf (fl_set_counter_bounds, g-> ob_generic, args);
  1029. }
  1030.  
  1031. static PyObject *
  1032. set_counter_step (g, args)
  1033.     genericobject *g;
  1034.     PyObject *args;
  1035. {
  1036.     return call_forms_INfINf (fl_set_counter_step, g-> ob_generic, args);
  1037. }
  1038.  
  1039. static PyObject *
  1040. set_counter_return (g, args)
  1041.     genericobject *g;
  1042.     PyObject *args;
  1043. {
  1044.     return call_forms_INi (fl_set_counter_return, g-> ob_generic, args);
  1045. }
  1046.  
  1047. static PyMethodDef counter_methods[] = {
  1048.     {"set_counter_value",        (PyCFunction)set_counter_value},
  1049.     {"get_counter_value",        (PyCFunction)get_counter_value},
  1050.     {"set_counter_bounds",        (PyCFunction)set_counter_bounds},
  1051.     {"set_counter_step",        (PyCFunction)set_counter_step},
  1052.     {"set_counter_precision",    (PyCFunction)set_counter_precision},
  1053.     {"set_counter_return",        (PyCFunction)set_counter_return},
  1054.     {NULL,                NULL}        /* sentinel */
  1055. };
  1056.  
  1057.  
  1058. /* Class: Dials */
  1059.  
  1060. static PyObject *
  1061. get_dial_value(g, args)
  1062.     genericobject *g;
  1063.     PyObject *args;
  1064. {
  1065.     return call_forms_Rf (fl_get_dial_value, g-> ob_generic, args);
  1066. }
  1067.  
  1068. static PyObject *
  1069. set_dial_value (g, args)
  1070.     genericobject *g;
  1071.     PyObject *args;
  1072. {
  1073.     return call_forms_INf (fl_set_dial_value, g-> ob_generic, args);
  1074. }
  1075.  
  1076. static PyObject *
  1077. set_dial_bounds (g, args)
  1078.     genericobject *g;
  1079.     PyObject *args;
  1080. {
  1081.     return call_forms_INfINf (fl_set_dial_bounds, g-> ob_generic, args);
  1082. }
  1083.  
  1084. static PyObject *
  1085. get_dial_bounds (g, args)
  1086.     genericobject *g;
  1087.     PyObject *args;
  1088. {
  1089.     return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic, args);
  1090. }
  1091.  
  1092. static PyObject *
  1093. set_dial_step (g, args)
  1094.     genericobject *g;
  1095.     PyObject *args;
  1096. {
  1097.     return call_forms_INf (fl_set_dial_step, g-> ob_generic, args);
  1098. }
  1099.  
  1100. static PyMethodDef dial_methods[] = {
  1101.     {"set_dial_value",    (PyCFunction)set_dial_value},
  1102.     {"get_dial_value",    (PyCFunction)get_dial_value},
  1103.     {"set_dial_bounds",    (PyCFunction)set_dial_bounds},
  1104.     {"get_dial_bounds",    (PyCFunction)get_dial_bounds},
  1105.     {"set_dial_step",    (PyCFunction)set_dial_step},
  1106.     {NULL,            NULL}        /* sentinel */
  1107. };
  1108.  
  1109. /* Class : Input */
  1110.  
  1111. static PyObject *
  1112. set_input (g, args)
  1113.     genericobject *g;
  1114.     PyObject *args;
  1115. {
  1116.     return call_forms_INstr (fl_set_input, g-> ob_generic, args);
  1117. }
  1118.  
  1119. static PyObject *
  1120. get_input (g, args)
  1121.     genericobject *g;
  1122.     PyObject *args;
  1123. {
  1124.     return call_forms_Rstr (fl_get_input, g-> ob_generic, args);
  1125. }
  1126.  
  1127. static PyObject *
  1128. set_input_color (g, args)
  1129.     genericobject *g;
  1130.     PyObject *args;
  1131. {
  1132.     return call_forms_INfINf (fl_set_input_color, g-> ob_generic, args);
  1133. }
  1134.  
  1135. static PyObject *
  1136. set_input_return (g, args)
  1137.     genericobject *g;
  1138.     PyObject *args;
  1139. {
  1140.     return call_forms_INi (fl_set_input_return, g-> ob_generic, args);
  1141. }
  1142.  
  1143. static PyMethodDef input_methods[] = {
  1144.     {"set_input",        (PyCFunction)set_input},
  1145.     {"get_input",        (PyCFunction)get_input},
  1146.     {"set_input_color",    (PyCFunction)set_input_color},
  1147.     {"set_input_return",    (PyCFunction)set_input_return},
  1148.     {NULL,            NULL}        /* sentinel */
  1149. };
  1150.  
  1151.  
  1152. /* Class : Menu */
  1153.  
  1154. static PyObject *
  1155. set_menu (g, args)
  1156.     genericobject *g;
  1157.     PyObject *args;
  1158. {
  1159.     return call_forms_INstr (fl_set_menu, g-> ob_generic, args);
  1160. }
  1161.  
  1162. static PyObject *
  1163. get_menu (g, args)
  1164.     genericobject *g;
  1165.     PyObject *args;
  1166. {
  1167.     /* XXX strictly speaking this is wrong since fl_get_menu
  1168.        XXX returns long, not int */
  1169.     return call_forms_Ri (fl_get_menu, g-> ob_generic, args);
  1170. }
  1171.  
  1172. static PyObject *
  1173. get_menu_text (g, args)
  1174.     genericobject *g;
  1175.     PyObject *args;
  1176. {
  1177.     return call_forms_Rstr (fl_get_menu_text, g-> ob_generic, args);
  1178. }
  1179.  
  1180. static PyObject *
  1181. addto_menu (g, args)
  1182.     genericobject *g;
  1183.     PyObject *args;
  1184. {
  1185.     return call_forms_INstr (fl_addto_menu, g-> ob_generic, args);
  1186. }
  1187.  
  1188. static PyMethodDef menu_methods[] = {
  1189.     {"set_menu",        (PyCFunction)set_menu},
  1190.     {"get_menu",        (PyCFunction)get_menu},
  1191.     {"get_menu_text",    (PyCFunction)get_menu_text},
  1192.     {"addto_menu",        (PyCFunction)addto_menu},
  1193.     {NULL,            NULL}        /* sentinel */
  1194. };
  1195.  
  1196.  
  1197. /* Class: Sliders */
  1198.  
  1199. static PyObject *
  1200. get_slider_value(g, args)
  1201.     genericobject *g;
  1202.     PyObject *args;
  1203. {
  1204.     return call_forms_Rf (fl_get_slider_value, g-> ob_generic, args);
  1205. }
  1206.  
  1207. static PyObject *
  1208. set_slider_value (g, args)
  1209.     genericobject *g;
  1210.     PyObject *args;
  1211. {
  1212.     return call_forms_INf (fl_set_slider_value, g-> ob_generic, args);
  1213. }
  1214.  
  1215. static PyObject *
  1216. set_slider_bounds (g, args)
  1217.     genericobject *g;
  1218.     PyObject *args;
  1219. {
  1220.     return call_forms_INfINf (fl_set_slider_bounds, g-> ob_generic, args);
  1221. }
  1222.  
  1223. static PyObject *
  1224. get_slider_bounds (g, args)
  1225.     genericobject *g;
  1226.     PyObject *args;
  1227. {
  1228.     return call_forms_OUTfOUTf(fl_get_slider_bounds, g-> ob_generic, args);
  1229. }
  1230.  
  1231. static PyObject *
  1232. set_slider_return (g, args)
  1233.     genericobject *g;
  1234.     PyObject *args;
  1235. {
  1236.     return call_forms_INf (fl_set_slider_return, g-> ob_generic, args);
  1237. }
  1238.  
  1239. static PyObject *
  1240. set_slider_size (g, args)
  1241.     genericobject *g;
  1242.     PyObject *args;
  1243. {
  1244.     return call_forms_INf (fl_set_slider_size, g-> ob_generic, args);
  1245. }
  1246.  
  1247. static PyObject *
  1248. set_slider_precision (g, args)
  1249.     genericobject *g;
  1250.     PyObject *args;
  1251. {
  1252.     return call_forms_INi (fl_set_slider_precision, g-> ob_generic, args);
  1253. }
  1254.  
  1255. static PyObject *
  1256. set_slider_step (g, args)
  1257.     genericobject *g;
  1258.     PyObject *args;
  1259. {
  1260.     return call_forms_INf (fl_set_slider_step, g-> ob_generic, args);
  1261. }
  1262.  
  1263.  
  1264. static PyMethodDef slider_methods[] = {
  1265.     {"set_slider_value",    (PyCFunction)set_slider_value},
  1266.     {"get_slider_value",    (PyCFunction)get_slider_value},
  1267.     {"set_slider_bounds",    (PyCFunction)set_slider_bounds},
  1268.     {"get_slider_bounds",    (PyCFunction)get_slider_bounds},
  1269.     {"set_slider_return",    (PyCFunction)set_slider_return},
  1270.     {"set_slider_size",    (PyCFunction)set_slider_size},
  1271.     {"set_slider_precision",(PyCFunction)set_slider_precision},
  1272.     {"set_slider_step",    (PyCFunction)set_slider_step},
  1273.     {NULL,            NULL}        /* sentinel */
  1274. };
  1275.  
  1276. static PyObject *
  1277. set_positioner_xvalue (g, args)
  1278.     genericobject *g;
  1279.     PyObject *args;
  1280. {
  1281.     return call_forms_INf (fl_set_positioner_xvalue, g-> ob_generic, args);
  1282. }
  1283.  
  1284. static PyObject *
  1285. set_positioner_xbounds (g, args)
  1286.     genericobject *g;
  1287.     PyObject *args;
  1288. {
  1289.     return call_forms_INfINf (fl_set_positioner_xbounds,
  1290.                   g-> ob_generic, args);
  1291. }
  1292.  
  1293. static PyObject *
  1294. set_positioner_yvalue (g, args)
  1295.     genericobject *g;
  1296.     PyObject *args;
  1297. {
  1298.     return call_forms_INf (fl_set_positioner_yvalue, g-> ob_generic, args);
  1299. }
  1300.  
  1301. static PyObject *
  1302. set_positioner_ybounds (g, args)
  1303.     genericobject *g;
  1304.     PyObject *args;
  1305. {
  1306.     return call_forms_INfINf (fl_set_positioner_ybounds,
  1307.                   g-> ob_generic, args);
  1308. }
  1309.  
  1310. static PyObject *
  1311. get_positioner_xvalue (g, args)
  1312.     genericobject *g;
  1313.     PyObject *args;
  1314. {
  1315.     return call_forms_Rf (fl_get_positioner_xvalue, g-> ob_generic, args);
  1316. }
  1317.  
  1318. static PyObject *
  1319. get_positioner_xbounds (g, args)
  1320.     genericobject *g;
  1321.     PyObject *args;
  1322. {
  1323.     return call_forms_OUTfOUTf (fl_get_positioner_xbounds,
  1324.                     g-> ob_generic, args);
  1325. }
  1326.  
  1327. static PyObject *
  1328. get_positioner_yvalue (g, args)
  1329.     genericobject *g;
  1330.     PyObject *args;
  1331. {
  1332.     return call_forms_Rf (fl_get_positioner_yvalue, g-> ob_generic, args);
  1333. }
  1334.  
  1335. static PyObject *
  1336. get_positioner_ybounds (g, args)
  1337.     genericobject *g;
  1338.     PyObject *args;
  1339. {
  1340.     return call_forms_OUTfOUTf (fl_get_positioner_ybounds,
  1341.                     g-> ob_generic, args);
  1342. }
  1343.  
  1344. static PyMethodDef positioner_methods[] = {
  1345.     {"set_positioner_xvalue",    (PyCFunction)set_positioner_xvalue},
  1346.     {"set_positioner_yvalue",    (PyCFunction)set_positioner_yvalue},
  1347.     {"set_positioner_xbounds",    (PyCFunction)set_positioner_xbounds},
  1348.     {"set_positioner_ybounds",    (PyCFunction)set_positioner_ybounds},
  1349.     {"get_positioner_xvalue",    (PyCFunction)get_positioner_xvalue},
  1350.     {"get_positioner_yvalue",    (PyCFunction)get_positioner_yvalue},
  1351.     {"get_positioner_xbounds",    (PyCFunction)get_positioner_xbounds},
  1352.     {"get_positioner_ybounds",    (PyCFunction)get_positioner_ybounds},
  1353.     {NULL,            NULL}        /* sentinel */
  1354. };
  1355.  
  1356. /* Class timer */
  1357.  
  1358. static PyObject *
  1359. set_timer (g, args)
  1360.     genericobject *g;
  1361.     PyObject *args;
  1362. {
  1363.     return call_forms_INf (fl_set_timer, g-> ob_generic, args);
  1364. }
  1365.  
  1366. static PyObject *
  1367. get_timer (g, args)
  1368.     genericobject *g;
  1369.     PyObject *args;
  1370. {
  1371.     return call_forms_Rf (fl_get_timer, g-> ob_generic, args);
  1372. }
  1373.  
  1374. static PyMethodDef timer_methods[] = {
  1375.     {"set_timer",        (PyCFunction)set_timer},
  1376.     {"get_timer",        (PyCFunction)get_timer},
  1377.     {NULL,            NULL}        /* sentinel */
  1378. };
  1379.  
  1380. /* Form objects */
  1381.  
  1382. typedef struct {
  1383.     PyObject_HEAD
  1384.     FL_FORM *ob_form;
  1385. } formobject;
  1386.  
  1387. staticforward PyTypeObject Formtype;
  1388.  
  1389. #define is_formobject(v) ((v)->ob_type == &Formtype)
  1390.  
  1391. static PyObject *
  1392. form_show_form(f, args)
  1393.     formobject *f;
  1394.     PyObject *args;
  1395. {
  1396.     int place, border;
  1397.     char *name;
  1398.     if (!PyArg_Parse(args, "(iis)", &place, &border, &name))
  1399.         return NULL;
  1400.     fl_show_form(f->ob_form, place, border, name);
  1401.     Py_INCREF(Py_None);
  1402.     return Py_None;
  1403. }
  1404.  
  1405. static PyObject *
  1406. form_call(func, f, args)
  1407.     FL_FORM *f;
  1408.     PyObject *args;
  1409.     void (*func)(FL_FORM *);
  1410. {
  1411.     if (!PyArg_NoArgs(args)) return NULL;
  1412.  
  1413.     (*func)(f);
  1414.  
  1415.     Py_INCREF(Py_None);
  1416.     return Py_None;
  1417. }
  1418.  
  1419. static PyObject *
  1420. form_call_INiINi(func, f, args)
  1421.     FL_FORM *f;
  1422.     PyObject *args;
  1423.     void (*func)(FL_FORM *, int, int);
  1424. {
  1425.     int a, b;
  1426.  
  1427.     if (!PyArg_Parse(args, "(ii)", &a, &b)) return NULL;
  1428.  
  1429.     (*func)(f, a, b);
  1430.  
  1431.     Py_INCREF(Py_None);
  1432.     return Py_None;
  1433. }
  1434.  
  1435. static PyObject *
  1436. form_call_INfINf(func, f, args)
  1437.     FL_FORM *f;
  1438.     PyObject *args;
  1439.     void (*func)(FL_FORM *, float, float);
  1440. {
  1441.     float a, b;
  1442.  
  1443.     if (!PyArg_Parse(args, "(ff)", &a, &b)) return NULL;
  1444.  
  1445.     (*func)(f, a, b);
  1446.  
  1447.     Py_INCREF(Py_None);
  1448.     return Py_None;
  1449. }
  1450.  
  1451. static PyObject *
  1452. form_hide_form(f, args)
  1453.     formobject *f;
  1454.     PyObject *args;
  1455. {
  1456.     return form_call(fl_hide_form, f-> ob_form, args);
  1457. }
  1458.  
  1459. static PyObject *
  1460. form_redraw_form(f, args)
  1461.     formobject *f;
  1462.     PyObject *args;
  1463. {
  1464.     return form_call(fl_redraw_form, f-> ob_form, args);
  1465. }
  1466.  
  1467. static PyObject *
  1468. form_set_form_position(f, args)
  1469.     formobject *f;
  1470.     PyObject *args;
  1471. {
  1472.     return form_call_INiINi(fl_set_form_position, f-> ob_form, args);
  1473. }
  1474.  
  1475. static PyObject *
  1476. form_set_form_size(f, args)
  1477.     formobject *f;
  1478.     PyObject *args;
  1479. {
  1480.     return form_call_INiINi(fl_set_form_size, f-> ob_form, args);
  1481. }
  1482.  
  1483. static PyObject *
  1484. form_scale_form(f, args)
  1485.     formobject *f;
  1486.     PyObject *args;
  1487. {
  1488.     return form_call_INfINf(fl_scale_form, f-> ob_form, args);
  1489. }
  1490.  
  1491. static PyObject *
  1492. generic_add_object(f, args, func, internal_methods)
  1493.     formobject *f;
  1494.     PyObject *args;
  1495.     FL_OBJECT *(*func)(int, float, float, float, float, char*);
  1496.     PyMethodDef *internal_methods;
  1497. {
  1498.     int type;
  1499.     float x, y, w, h;
  1500.     char *name;
  1501.     FL_OBJECT *obj;
  1502.  
  1503.     if (!PyArg_Parse(args,"(iffffs)", &type,&x,&y,&w,&h,&name))
  1504.         return NULL;
  1505.  
  1506.     fl_addto_form (f-> ob_form);
  1507.  
  1508.     obj = (*func) (type, x, y, w, h, name);
  1509.  
  1510.     fl_end_form();
  1511.  
  1512.     if (obj == NULL) {
  1513.         PyErr_NoMemory();
  1514.         return NULL;
  1515.     }
  1516.  
  1517.     return newgenericobject (obj, internal_methods);
  1518. }
  1519.  
  1520. static PyObject *
  1521. form_add_button(f, args)
  1522.     formobject *f;
  1523.     PyObject *args;
  1524. {
  1525.     return generic_add_object(f, args, fl_add_button, button_methods);
  1526. }
  1527.  
  1528. static PyObject *
  1529. form_add_lightbutton(f, args)
  1530.     formobject *f;
  1531.     PyObject *args;
  1532. {
  1533.     return generic_add_object(f, args, fl_add_lightbutton, button_methods);
  1534. }
  1535.  
  1536. static PyObject *
  1537. form_add_roundbutton(f, args)
  1538.     formobject *f;
  1539.     PyObject *args;
  1540. {
  1541.     return generic_add_object(f, args, fl_add_roundbutton, button_methods);
  1542. }
  1543.  
  1544. static PyObject *
  1545. form_add_menu (f, args)
  1546.     formobject *f;
  1547.     PyObject *args;
  1548. {
  1549.     return generic_add_object(f, args, fl_add_menu, menu_methods);
  1550. }
  1551.  
  1552. static PyObject *
  1553. form_add_slider(f, args)
  1554.     formobject *f;
  1555.     PyObject *args;
  1556. {
  1557.     return generic_add_object(f, args, fl_add_slider, slider_methods);
  1558. }
  1559.  
  1560. static PyObject *
  1561. form_add_valslider(f, args)
  1562.     formobject *f;
  1563.     PyObject *args;
  1564. {
  1565.     return generic_add_object(f, args, fl_add_valslider, slider_methods);
  1566. }
  1567.  
  1568. static PyObject *
  1569. form_add_dial(f, args)
  1570.     formobject *f;
  1571.     PyObject *args;
  1572. {
  1573.     return generic_add_object(f, args, fl_add_dial, dial_methods);
  1574. }
  1575.  
  1576. static PyObject *
  1577. form_add_counter(f, args)
  1578.     formobject *f;
  1579.     PyObject *args;
  1580. {
  1581.     return generic_add_object(f, args, fl_add_counter, counter_methods);
  1582. }
  1583.  
  1584. static PyObject *
  1585. form_add_clock(f, args)
  1586.     formobject *f;
  1587.     PyObject *args;
  1588. {
  1589.     return generic_add_object(f, args, fl_add_clock, clock_methods);
  1590. }
  1591.  
  1592. static PyObject *
  1593. form_add_box(f, args)
  1594.     formobject *f;
  1595.     PyObject *args;
  1596. {
  1597.     return generic_add_object(f, args, fl_add_box,
  1598.                   (PyMethodDef *)NULL);
  1599. }
  1600.  
  1601. static PyObject *
  1602. form_add_choice(f, args)
  1603.     formobject *f;
  1604.     PyObject *args;
  1605. {
  1606.     return generic_add_object(f, args, fl_add_choice, choice_methods);
  1607. }
  1608.  
  1609. static PyObject *
  1610. form_add_browser(f, args)
  1611.     formobject *f;
  1612.     PyObject *args;
  1613. {
  1614.     return generic_add_object(f, args, fl_add_browser, browser_methods);
  1615. }
  1616.  
  1617. static PyObject *
  1618. form_add_positioner(f, args)
  1619.     formobject *f;
  1620.     PyObject *args;
  1621. {
  1622.     return generic_add_object(f, args, fl_add_positioner,
  1623.                   positioner_methods);
  1624. }
  1625.  
  1626. static PyObject *
  1627. form_add_input(f, args)
  1628.     formobject *f;
  1629.     PyObject *args;
  1630. {
  1631.     return generic_add_object(f, args, fl_add_input, input_methods);
  1632. }
  1633.  
  1634. static PyObject *
  1635. form_add_text(f, args)
  1636.     formobject *f;
  1637.     PyObject *args;
  1638. {
  1639.     return generic_add_object(f, args, fl_add_text,
  1640.                   (PyMethodDef *)NULL);
  1641. }
  1642.  
  1643. static PyObject *
  1644. form_add_timer(f, args)
  1645.     formobject *f;
  1646.     PyObject *args;
  1647. {
  1648.     return generic_add_object(f, args, fl_add_timer, timer_methods);
  1649. }
  1650.  
  1651. static PyObject *
  1652. form_freeze_form(f, args)
  1653.     formobject *f;
  1654.     PyObject *args;
  1655. {
  1656.     return form_call(fl_freeze_form, f-> ob_form, args);
  1657. }
  1658.  
  1659. static PyObject *
  1660. form_unfreeze_form(f, args)
  1661.     formobject *f;
  1662.     PyObject *args;
  1663. {
  1664.     return form_call(fl_unfreeze_form, f-> ob_form, args);
  1665. }
  1666.  
  1667. static PyObject *
  1668. form_activate_form(f, args)
  1669.     formobject *f;
  1670.     PyObject *args;
  1671. {
  1672.     return form_call(fl_activate_form, f-> ob_form, args);
  1673. }
  1674.  
  1675. static PyObject *
  1676. form_deactivate_form(f, args)
  1677.     formobject *f;
  1678.     PyObject *args;
  1679. {
  1680.     return form_call(fl_deactivate_form, f-> ob_form, args);
  1681. }
  1682.  
  1683. static PyObject *
  1684. form_bgn_group(f, args)
  1685.     formobject *f;
  1686.     PyObject *args;
  1687. {
  1688.     FL_OBJECT *obj;
  1689.  
  1690.     fl_addto_form(f-> ob_form);
  1691.     obj = fl_bgn_group();
  1692.     fl_end_form();
  1693.  
  1694.     if (obj == NULL) {
  1695.         PyErr_NoMemory();
  1696.         return NULL;
  1697.     }
  1698.  
  1699.     return newgenericobject (obj, (PyMethodDef *) NULL);
  1700. }
  1701.  
  1702. static PyObject *
  1703. form_end_group(f, args)
  1704.     formobject *f;
  1705.     PyObject *args;
  1706. {
  1707.     fl_addto_form(f-> ob_form);
  1708.     fl_end_group();
  1709.     fl_end_form();
  1710.     Py_INCREF(Py_None);
  1711.     return Py_None;
  1712. }
  1713.  
  1714. static PyObject *
  1715. forms_find_first_or_last(func, f, args)
  1716.     FL_OBJECT *(*func)(FL_FORM *, int, float, float);
  1717.     formobject *f;
  1718.     PyObject *args;
  1719. {
  1720.     int type;
  1721.     float mx, my;
  1722.     FL_OBJECT *generic;
  1723.     genericobject *g;
  1724.     
  1725.     if (!PyArg_Parse(args, "(iff)", &type, &mx, &my)) return NULL;
  1726.  
  1727.     generic = (*func) (f-> ob_form, type, mx, my);
  1728.  
  1729.     if (generic == NULL)
  1730.     {
  1731.         Py_INCREF(Py_None);
  1732.         return Py_None;
  1733.     }
  1734.  
  1735.     g = findgeneric(generic);
  1736.     if (g == NULL) {
  1737.         PyErr_SetString(PyExc_RuntimeError,
  1738.                "forms_find_{first|last} returns unknown object");
  1739.         return NULL;
  1740.     }
  1741.     Py_INCREF(g);
  1742.     return (PyObject *) g;
  1743. }
  1744.  
  1745. static PyObject *
  1746. form_find_first(f, args)
  1747.     formobject *f;
  1748.     PyObject *args;
  1749. {
  1750.     return forms_find_first_or_last(fl_find_first, f, args);
  1751. }
  1752.  
  1753. static PyObject *
  1754. form_find_last(f, args)
  1755.     formobject *f;
  1756.     PyObject *args;
  1757. {
  1758.     return forms_find_first_or_last(fl_find_last, f, args);
  1759. }
  1760.  
  1761. static PyObject *
  1762. form_set_object_focus(f, args)
  1763.     formobject *f;
  1764.     PyObject *args;
  1765. {
  1766.     genericobject *g;
  1767.     if (args == NULL || !is_genericobject(args)) {
  1768.         PyErr_BadArgument();
  1769.         return NULL;
  1770.     }
  1771.     g = (genericobject *)args;
  1772.     fl_set_object_focus(f->ob_form, g->ob_generic);
  1773.     Py_INCREF(Py_None);
  1774.     return Py_None;
  1775. }
  1776.  
  1777. static PyMethodDef form_methods[] = {
  1778. /* adm */
  1779.     {"show_form",        (PyCFunction)form_show_form},
  1780.     {"hide_form",        (PyCFunction)form_hide_form},
  1781.     {"redraw_form",        (PyCFunction)form_redraw_form},
  1782.     {"set_form_position",    (PyCFunction)form_set_form_position},
  1783.     {"set_form_size",    (PyCFunction)form_set_form_size},
  1784.     {"scale_form",        (PyCFunction)form_scale_form},
  1785.     {"freeze_form",        (PyCFunction)form_freeze_form},
  1786.     {"unfreeze_form",    (PyCFunction)form_unfreeze_form},
  1787.     {"activate_form",    (PyCFunction)form_activate_form},
  1788.     {"deactivate_form",    (PyCFunction)form_deactivate_form},
  1789.     {"bgn_group",        (PyCFunction)form_bgn_group},
  1790.     {"end_group",        (PyCFunction)form_end_group},
  1791.     {"find_first",        (PyCFunction)form_find_first},
  1792.     {"find_last",        (PyCFunction)form_find_last},
  1793.     {"set_object_focus",    (PyCFunction)form_set_object_focus},
  1794.  
  1795. /* basic objects */
  1796.     {"add_button",        (PyCFunction)form_add_button},
  1797. /*    {"add_bitmap",        (method)form_add_bitmap}, */
  1798.     {"add_lightbutton",    (PyCFunction)form_add_lightbutton},
  1799.     {"add_roundbutton",    (PyCFunction)form_add_roundbutton},
  1800.     {"add_menu",        (PyCFunction)form_add_menu},
  1801.     {"add_slider",        (PyCFunction)form_add_slider},
  1802.     {"add_positioner",    (PyCFunction)form_add_positioner},
  1803.     {"add_valslider",    (PyCFunction)form_add_valslider},
  1804.     {"add_dial",        (PyCFunction)form_add_dial},
  1805.     {"add_counter",        (PyCFunction)form_add_counter},
  1806.     {"add_box",        (PyCFunction)form_add_box},
  1807.     {"add_clock",        (PyCFunction)form_add_clock},
  1808.     {"add_choice",        (PyCFunction)form_add_choice},
  1809.     {"add_browser",        (PyCFunction)form_add_browser},
  1810.     {"add_input",        (PyCFunction)form_add_input},
  1811.     {"add_timer",        (PyCFunction)form_add_timer},
  1812.     {"add_text",        (PyCFunction)form_add_text},
  1813.     {NULL,            NULL}        /* sentinel */
  1814. };
  1815.  
  1816. static void
  1817. form_dealloc(f)
  1818.     formobject *f;
  1819. {
  1820.     releaseobjects(f->ob_form);
  1821.     if (f->ob_form->visible)
  1822.         fl_hide_form(f->ob_form);
  1823.     fl_free_form(f->ob_form);
  1824.     PyObject_Del(f);
  1825. }
  1826.  
  1827. #define OFF(x) offsetof(FL_FORM, x)
  1828.  
  1829. static struct memberlist form_memberlist[] = {
  1830.     {"window",    T_LONG,        OFF(window),    RO},
  1831.     {"w",        T_FLOAT,    OFF(w)},
  1832.     {"h",        T_FLOAT,    OFF(h)},
  1833.     {"x",        T_FLOAT,    OFF(x),        RO},
  1834.     {"y",        T_FLOAT,    OFF(y),        RO},
  1835.     {"deactivated",    T_INT,        OFF(deactivated)},
  1836.     {"visible",    T_INT,        OFF(visible),    RO},
  1837.     {"frozen",    T_INT,        OFF(frozen),    RO},
  1838.     {"doublebuf",    T_INT,        OFF(doublebuf)},
  1839.     {NULL}    /* Sentinel */
  1840. };
  1841.  
  1842. #undef OFF
  1843.  
  1844. static PyObject *
  1845. form_getattr(f, name)
  1846.     formobject *f;
  1847.     char *name;
  1848. {
  1849.     PyObject *meth;
  1850.  
  1851.     meth = Py_FindMethod(form_methods, (PyObject *)f, name);
  1852.     if (meth != NULL)
  1853.         return meth;
  1854.     PyErr_Clear();
  1855.     return PyMember_Get((char *)f->ob_form, form_memberlist, name);
  1856. }
  1857.  
  1858. static int
  1859. form_setattr(f, name, v)
  1860.     formobject *f;
  1861.     char *name;
  1862.     PyObject *v;
  1863. {
  1864.     if (v == NULL) {
  1865.         PyErr_SetString(PyExc_TypeError,
  1866.                 "can't delete form attributes");
  1867.         return -1;
  1868.     }
  1869.  
  1870.     return PyMember_Set((char *)f->ob_form, form_memberlist, name, v);
  1871. }
  1872.  
  1873. static PyObject *
  1874. form_repr(f)
  1875.     formobject *f;
  1876. {
  1877.     char buf[100];
  1878.     sprintf(buf, "<FORMS_form at %lx, window=%ld>",
  1879.         (long)f, f->ob_form->window);
  1880.     return PyString_FromString(buf);
  1881. }
  1882.  
  1883. static PyTypeObject Formtype = {
  1884.     PyObject_HEAD_INIT(&PyType_Type)
  1885.     0,                /*ob_size*/
  1886.     "FORMS_form",            /*tp_name*/
  1887.     sizeof(formobject),        /*tp_size*/
  1888.     0,                /*tp_itemsize*/
  1889.     /* methods */
  1890.     (destructor)form_dealloc,    /*tp_dealloc*/
  1891.     0,                /*tp_print*/
  1892.     (getattrfunc)form_getattr,    /*tp_getattr*/
  1893.     (setattrfunc)form_setattr,    /*tp_setattr*/
  1894.     0,                /*tp_compare*/
  1895.     (reprfunc)form_repr,        /*tp_repr*/
  1896. };
  1897.  
  1898. static PyObject *
  1899. newformobject(form)
  1900.     FL_FORM *form;
  1901. {
  1902.     formobject *f;
  1903.     f = PyObject_New(formobject, &Formtype);
  1904.     if (f == NULL)
  1905.         return NULL;
  1906.     f->ob_form = form;
  1907.     return (PyObject *)f;
  1908. }
  1909.  
  1910.  
  1911. /* The "fl" module */
  1912.  
  1913. static PyObject *
  1914. forms_make_form(dummy, args)
  1915.     PyObject *dummy;
  1916.     PyObject *args;
  1917. {
  1918.     int type;
  1919.     float w, h;
  1920.     FL_FORM *form;
  1921.     if (!PyArg_Parse(args, "(iff)", &type, &w, &h))
  1922.         return NULL;
  1923.     form = fl_bgn_form(type, w, h);
  1924.     if (form == NULL) {
  1925.         /* XXX Actually, cannot happen! */
  1926.         PyErr_NoMemory();
  1927.         return NULL;
  1928.     }
  1929.     fl_end_form();
  1930.     return newformobject(form);
  1931. }
  1932.  
  1933. static PyObject *
  1934. forms_activate_all_forms(f, args)
  1935.     PyObject *f;
  1936.     PyObject *args;
  1937. {
  1938.     fl_activate_all_forms();
  1939.     Py_INCREF(Py_None);
  1940.     return Py_None;
  1941. }
  1942.  
  1943. static PyObject *
  1944. forms_deactivate_all_forms(f, args)
  1945.     PyObject *f;
  1946.     PyObject *args;
  1947. {
  1948.     fl_deactivate_all_forms();
  1949.     Py_INCREF(Py_None);
  1950.     return Py_None;
  1951. }
  1952.  
  1953. static PyObject *my_event_callback = NULL;
  1954.  
  1955. static PyObject *
  1956. forms_set_event_call_back(dummy, args)
  1957.     PyObject *dummy;
  1958.     PyObject *args;
  1959. {
  1960.     if (args == Py_None)
  1961.         args = NULL;
  1962.     my_event_callback = args;
  1963.     Py_XINCREF(args);
  1964.     Py_INCREF(Py_None);
  1965.     return Py_None;
  1966. }
  1967.  
  1968. static PyObject *
  1969. forms_do_or_check_forms(dummy, args, func)
  1970.     PyObject *dummy;
  1971.     PyObject *args;
  1972.     FL_OBJECT *(*func)();
  1973. {
  1974.     FL_OBJECT *generic;
  1975.     genericobject *g;
  1976.     PyObject *arg, *res;
  1977.     
  1978.     if (!PyArg_NoArgs(args))
  1979.         return NULL;
  1980.  
  1981.     for (;;) {
  1982.         Py_BEGIN_ALLOW_THREADS
  1983.         generic = (*func)();
  1984.         Py_END_ALLOW_THREADS
  1985.         if (generic == NULL) {
  1986.             Py_INCREF(Py_None);
  1987.             return Py_None;
  1988.         }
  1989.         if (generic == FL_EVENT) {
  1990.             int dev;
  1991.             short val;
  1992.             if (my_event_callback == NULL)
  1993.                 return PyInt_FromLong(-1L);
  1994.             dev = fl_qread(&val);
  1995.             arg = Py_BuildValue("(ih)", dev, val);
  1996.             if (arg == NULL)
  1997.                 return NULL;
  1998.             res = PyEval_CallObject(my_event_callback, arg);
  1999.             Py_XDECREF(res);
  2000.             Py_DECREF(arg);
  2001.             if (res == NULL)
  2002.                 return NULL; /* Callback raised exception */
  2003.             continue;
  2004.         }
  2005.         g = findgeneric(generic);
  2006.         if (g == NULL) {
  2007.             /* Object not known to us (some dialogs cause this) */
  2008.             continue; /* Ignore it */
  2009.         }
  2010.         if (g->ob_callback == NULL) {
  2011.             Py_INCREF(g);
  2012.             return ((PyObject *) g);
  2013.         }
  2014.         arg = Py_BuildValue("(OO)", (PyObject *)g, g->ob_callback_arg);
  2015.         if (arg == NULL)
  2016.             return NULL;
  2017.         res = PyEval_CallObject(g->ob_callback, arg);
  2018.         Py_XDECREF(res);
  2019.         Py_DECREF(arg);
  2020.         if (res == NULL)
  2021.             return NULL; /* Callback raised exception */
  2022.     }
  2023. }
  2024.  
  2025. static PyObject *
  2026. forms_do_forms(dummy, args)
  2027.     PyObject *dummy;
  2028.     PyObject *args;
  2029. {
  2030.     return forms_do_or_check_forms(dummy, args, fl_do_forms);
  2031. }
  2032.  
  2033. static PyObject *
  2034. forms_check_forms(dummy, args)
  2035.     PyObject *dummy;
  2036.     PyObject *args;
  2037. {
  2038.     return forms_do_or_check_forms(dummy, args, fl_check_forms);
  2039. }
  2040.  
  2041. static PyObject *
  2042. forms_do_only_forms(dummy, args)
  2043.     PyObject *dummy;
  2044.     PyObject *args;
  2045. {
  2046.     return forms_do_or_check_forms(dummy, args, fl_do_only_forms);
  2047. }
  2048.  
  2049. static PyObject *
  2050. forms_check_only_forms(dummy, args)
  2051.     PyObject *dummy;
  2052.     PyObject *args;
  2053. {
  2054.     return forms_do_or_check_forms(dummy, args, fl_check_only_forms);
  2055. }
  2056.  
  2057. #ifdef UNUSED
  2058. static PyObject *
  2059. fl_call(func, args)
  2060.     PyObject *args;
  2061.     void (*func)();
  2062. {
  2063.     if (!PyArg_NoArgs(args))
  2064.         return NULL;
  2065.     (*func)();
  2066.     Py_INCREF(Py_None);
  2067.     return Py_None;
  2068. }
  2069. #endif
  2070.  
  2071. static PyObject *
  2072. forms_set_graphics_mode(dummy, args)
  2073.     PyObject *dummy;
  2074.     PyObject *args;
  2075. {
  2076.     int rgbmode, doublebuf;
  2077.  
  2078.     if (!PyArg_Parse(args, "(ii)", &rgbmode, &doublebuf))
  2079.         return NULL;
  2080.     fl_set_graphics_mode(rgbmode,doublebuf);
  2081.     Py_INCREF(Py_None);
  2082.     return Py_None;
  2083. }
  2084.  
  2085. static PyObject *
  2086. forms_get_rgbmode(dummy, args)
  2087.     PyObject *dummy;
  2088.     PyObject *args;
  2089. {
  2090.     extern int fl_rgbmode;
  2091.  
  2092.     if (args != NULL) {
  2093.         PyErr_BadArgument();
  2094.         return NULL;
  2095.     }
  2096.     return PyInt_FromLong((long)fl_rgbmode);
  2097. }
  2098.  
  2099. static PyObject *
  2100. forms_show_errors(dummy, args)
  2101.     PyObject *dummy;
  2102.     PyObject *args;
  2103. {
  2104.     int show;
  2105.     if (!PyArg_Parse(args, "i", &show))
  2106.         return NULL;
  2107.     fl_show_errors(show);
  2108.     Py_INCREF(Py_None);
  2109.     return Py_None;
  2110. }
  2111.  
  2112. static PyObject *
  2113. forms_set_font_name(dummy, args)
  2114.     PyObject *dummy;
  2115.     PyObject *args;
  2116. {
  2117.     int numb;
  2118.     char *name;
  2119.     if (!PyArg_Parse(args, "(is)", &numb, &name))
  2120.         return NULL;
  2121.     fl_set_font_name(numb, name);
  2122.     Py_INCREF(Py_None);
  2123.     return Py_None;
  2124. }
  2125.  
  2126.  
  2127. static PyObject *
  2128. forms_qdevice(self, args)
  2129.     PyObject *self;
  2130.     PyObject *args;
  2131. {
  2132.     short arg1;
  2133.     if (!PyArg_Parse(args, "h", &arg1))
  2134.         return NULL;
  2135.     fl_qdevice(arg1);
  2136.     Py_INCREF(Py_None);
  2137.     return Py_None;
  2138. }
  2139.  
  2140. static PyObject *
  2141. forms_unqdevice(self, args)
  2142.     PyObject *self;
  2143.     PyObject *args;
  2144. {
  2145.     short arg1;
  2146.     if (!PyArg_Parse(args, "h", &arg1))
  2147.         return NULL;
  2148.     fl_unqdevice(arg1);
  2149.     Py_INCREF(Py_None);
  2150.     return Py_None;
  2151. }
  2152.  
  2153. static PyObject *
  2154. forms_isqueued(self, args)
  2155.     PyObject *self;
  2156.     PyObject *args;
  2157. {
  2158.     long retval;
  2159.     short arg1;
  2160.     if (!PyArg_Parse(args, "h", &arg1))
  2161.         return NULL;
  2162.     retval = fl_isqueued(arg1);
  2163.  
  2164.     return PyInt_FromLong(retval);
  2165. }
  2166.  
  2167. static PyObject *
  2168. forms_qtest(self, args)
  2169.     PyObject *self;
  2170.     PyObject *args;
  2171. {
  2172.     long retval;
  2173.     retval = fl_qtest();
  2174.     return PyInt_FromLong(retval);
  2175. }
  2176.  
  2177.  
  2178. static PyObject *
  2179. forms_qread(self, args)
  2180.     PyObject *self;
  2181.     PyObject *args;
  2182. {
  2183.     int dev;
  2184.     short val;
  2185.     Py_BEGIN_ALLOW_THREADS
  2186.     dev = fl_qread(&val);
  2187.     Py_END_ALLOW_THREADS
  2188.     return Py_BuildValue("(ih)", dev, val);
  2189. }
  2190.  
  2191. static PyObject *
  2192. forms_qreset(self, args)
  2193.     PyObject *self;
  2194.     PyObject *args;
  2195. {
  2196.     if (!PyArg_NoArgs(args)) return NULL;
  2197.  
  2198.     fl_qreset();
  2199.     Py_INCREF(Py_None);
  2200.     return Py_None;
  2201. }
  2202.  
  2203. static PyObject *
  2204. forms_qenter(self, args)
  2205.     PyObject *self;
  2206.     PyObject *args;
  2207. {
  2208.     short arg1, arg2;
  2209.     if (!PyArg_Parse(args, "(hh)", &arg1, &arg2))
  2210.         return NULL;
  2211.     fl_qenter(arg1, arg2);
  2212.     Py_INCREF(Py_None);
  2213.     return Py_None;
  2214. }
  2215.  
  2216. static PyObject *
  2217. forms_color(self, args)
  2218.     PyObject *self;
  2219.     PyObject *args;
  2220. {
  2221.     int arg;
  2222.  
  2223.     if (!PyArg_Parse(args, "i", &arg)) return NULL;
  2224.  
  2225.     fl_color((short) arg);
  2226.  
  2227.     Py_INCREF(Py_None);
  2228.     return Py_None;
  2229. }
  2230.  
  2231. static PyObject *
  2232. forms_mapcolor(self, args)
  2233.     PyObject *self;
  2234.     PyObject *args;
  2235. {
  2236.     int arg0, arg1, arg2, arg3;
  2237.  
  2238.     if (!PyArg_Parse(args, "(iiii)", &arg0, &arg1, &arg2, &arg3))
  2239.         return NULL;
  2240.  
  2241.     fl_mapcolor(arg0, (short) arg1, (short) arg2, (short) arg3);
  2242.  
  2243.     Py_INCREF(Py_None);
  2244.     return Py_None;
  2245. }
  2246.  
  2247. static PyObject *
  2248. forms_getmcolor(self, args)
  2249.     PyObject *self;
  2250.     PyObject *args;
  2251. {
  2252.     int arg;
  2253.     short r, g, b;
  2254.  
  2255.     if (!PyArg_Parse(args, "i", &arg)) return NULL;
  2256.  
  2257.     fl_getmcolor(arg, &r, &g, &b);
  2258.  
  2259.     return Py_BuildValue("(hhh)", r, g, b);
  2260. }
  2261.  
  2262. static PyObject *
  2263. forms_get_mouse(self, args)
  2264.     PyObject *self;
  2265.     PyObject *args;
  2266. {
  2267.     float x, y;
  2268.  
  2269.     if (!PyArg_NoArgs(args)) return NULL;
  2270.     
  2271.     fl_get_mouse(&x, &y);
  2272.  
  2273.     return Py_BuildValue("(ff)", x, y);
  2274. }
  2275.  
  2276. static PyObject *
  2277. forms_tie(self, args)
  2278.     PyObject *self;
  2279.     PyObject *args;
  2280. {
  2281.     short arg1, arg2, arg3;
  2282.     if (!PyArg_Parse(args, "(hhh)", &arg1, &arg2, &arg3))
  2283.         return NULL;
  2284.     fl_tie(arg1, arg2, arg3);
  2285.     Py_INCREF(Py_None);
  2286.     return Py_None;
  2287. }
  2288.  
  2289. static PyObject *
  2290. forms_show_message(f, args)
  2291.     PyObject *f;
  2292.     PyObject *args;
  2293. {
  2294.     char *a, *b, *c;
  2295.  
  2296.     if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
  2297.  
  2298.     Py_BEGIN_ALLOW_THREADS
  2299.     fl_show_message(a, b, c);
  2300.     Py_END_ALLOW_THREADS
  2301.  
  2302.     Py_INCREF(Py_None);
  2303.     return Py_None;
  2304. }
  2305.  
  2306. static PyObject *
  2307. forms_show_choice(f, args)
  2308.     PyObject *f;
  2309.     PyObject *args;
  2310. {
  2311.     char *m1, *m2, *m3, *b1, *b2, *b3;
  2312.     int nb;
  2313.     char *format;
  2314.     long rv;
  2315.  
  2316.     if (args == NULL || !PyTuple_Check(args)) {
  2317.         PyErr_BadArgument();
  2318.         return NULL;
  2319.     }
  2320.     nb = PyTuple_Size(args) - 3;
  2321.     if (nb <= 0) {
  2322.         PyErr_SetString(PyExc_TypeError,
  2323.                 "need at least one button label");
  2324.         return NULL;
  2325.     }
  2326.     if (PyInt_Check(PyTuple_GetItem(args, 3))) {
  2327.         PyErr_SetString(PyExc_TypeError,
  2328.                "'number-of-buttons' argument not needed");
  2329.         return NULL;
  2330.     }
  2331.     switch (nb) {
  2332.     case 1: format = "(ssss)"; break;
  2333.     case 2: format = "(sssss)"; break;
  2334.     case 3: format = "(ssssss)"; break;
  2335.     default:
  2336.         PyErr_SetString(PyExc_TypeError, "too many button labels");
  2337.         return NULL;
  2338.     }
  2339.  
  2340.     if (!PyArg_Parse(args, format, &m1, &m2, &m3, &b1, &b2, &b3))
  2341.         return NULL;
  2342.  
  2343.     Py_BEGIN_ALLOW_THREADS
  2344.     rv = fl_show_choice(m1, m2, m3, nb, b1, b2, b3);
  2345.     Py_END_ALLOW_THREADS
  2346.     return PyInt_FromLong(rv);
  2347. }
  2348.  
  2349. static PyObject *
  2350. forms_show_question(f, args)
  2351.     PyObject *f;
  2352.     PyObject *args;
  2353. {
  2354.     int ret;
  2355.     char *a, *b, *c;
  2356.  
  2357.     if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
  2358.  
  2359.     Py_BEGIN_ALLOW_THREADS
  2360.     ret = fl_show_question(a, b, c);
  2361.     Py_END_ALLOW_THREADS
  2362.  
  2363.     return PyInt_FromLong((long) ret);
  2364. }
  2365.  
  2366. static PyObject *
  2367. forms_show_input(f, args)
  2368.     PyObject *f;
  2369.     PyObject *args;
  2370. {
  2371.     char *str;
  2372.     char *a, *b;
  2373.  
  2374.     if (!PyArg_Parse(args, "(ss)", &a, &b)) return NULL;
  2375.  
  2376.     Py_BEGIN_ALLOW_THREADS
  2377.     str = fl_show_input(a, b);
  2378.     Py_END_ALLOW_THREADS
  2379.  
  2380.     if (str == NULL) {
  2381.         Py_INCREF(Py_None);
  2382.         return Py_None;
  2383.     }
  2384.     return PyString_FromString(str);
  2385. }
  2386.  
  2387. static PyObject *
  2388. forms_file_selector(f, args)
  2389.     PyObject *f;
  2390.     PyObject *args;
  2391. {
  2392.     char *str;
  2393.     char *a, *b, *c, *d;
  2394.  
  2395.     if (!PyArg_Parse(args, "(ssss)", &a, &b, &c, &d)) return NULL;
  2396.  
  2397.     Py_BEGIN_ALLOW_THREADS
  2398.     str = fl_show_file_selector(a, b, c, d);
  2399.     Py_END_ALLOW_THREADS
  2400.  
  2401.     if (str == NULL) {
  2402.         Py_INCREF(Py_None);
  2403.         return Py_None;
  2404.     }
  2405.     return PyString_FromString(str);
  2406. }
  2407.  
  2408.  
  2409. static PyObject *
  2410. forms_file_selector_func(args, func)
  2411.     PyObject *args;
  2412.     char *(*func)();
  2413. {
  2414.     char *str;
  2415.  
  2416.     str = (*func) ();
  2417.  
  2418.     if (str == NULL) {
  2419.         Py_INCREF(Py_None);
  2420.         return Py_None;
  2421.     }
  2422.     return PyString_FromString(str);
  2423. }
  2424.  
  2425. static PyObject *
  2426. forms_get_directory(f, args)
  2427.     PyObject *f;
  2428.     PyObject *args;
  2429. {
  2430.     return forms_file_selector_func(args, fl_get_directory);
  2431. }
  2432.  
  2433. static PyObject *
  2434. forms_get_pattern(f, args)
  2435.     PyObject *f;
  2436.     PyObject *args;
  2437. {
  2438.     return forms_file_selector_func(args, fl_get_pattern);
  2439. }
  2440.  
  2441. static PyObject *
  2442. forms_get_filename(f, args)
  2443.     PyObject *f;
  2444.     PyObject *args;
  2445. {
  2446.     return forms_file_selector_func(args, fl_get_filename);
  2447. }
  2448.  
  2449. static PyMethodDef forms_methods[] = {
  2450. /* adm */
  2451.     {"make_form",        forms_make_form},
  2452.     {"activate_all_forms",    forms_activate_all_forms},
  2453.     {"deactivate_all_forms",forms_deactivate_all_forms},
  2454. /* gl support wrappers */
  2455.     {"qdevice",        forms_qdevice},
  2456.     {"unqdevice",        forms_unqdevice},
  2457.     {"isqueued",        forms_isqueued},
  2458.     {"qtest",        forms_qtest},
  2459.     {"qread",        forms_qread},
  2460. /*    {"blkqread",        forms_blkqread}, */
  2461.     {"qreset",        forms_qreset},
  2462.     {"qenter",        forms_qenter},
  2463.     {"get_mouse",        forms_get_mouse},
  2464.     {"tie",            forms_tie},
  2465. /*    {"new_events",        forms_new_events}, */
  2466.     {"color",        forms_color},
  2467.     {"mapcolor",        forms_mapcolor},
  2468.     {"getmcolor",        forms_getmcolor},
  2469. /* interaction */
  2470.     {"do_forms",        forms_do_forms},
  2471.     {"do_only_forms",    forms_do_only_forms},
  2472.     {"check_forms",        forms_check_forms},
  2473.     {"check_only_forms",    forms_check_only_forms},
  2474.     {"set_event_call_back",    forms_set_event_call_back},
  2475. /* goodies */
  2476.     {"show_message",    forms_show_message},
  2477.     {"show_question",    forms_show_question},
  2478.     {"show_choice",        forms_show_choice},
  2479.     {"show_input",        forms_show_input},
  2480.     {"show_file_selector",    forms_file_selector},
  2481.     {"file_selector",    forms_file_selector}, /* BW compat */
  2482.     {"get_directory",    forms_get_directory},
  2483.     {"get_pattern",        forms_get_pattern},
  2484.     {"get_filename",    forms_get_filename},
  2485.     {"set_graphics_mode",    forms_set_graphics_mode},
  2486.     {"get_rgbmode",        forms_get_rgbmode},
  2487.     {"show_errors",        forms_show_errors},
  2488.     {"set_font_name",    forms_set_font_name},
  2489.     {NULL,            NULL}        /* sentinel */
  2490. };
  2491.  
  2492. DL_EXPORT(void)
  2493. initfl()
  2494. {
  2495.     Py_InitModule("fl", forms_methods);
  2496.     foreground();
  2497.     fl_init();
  2498. }
  2499.  
  2500.  
  2501.  
  2502.